M

MLOG

తెలుగు

స్ట్రీమ్ ప్రాసెసింగ్‌ను విప్లవాత్మకంగా మార్చడానికి జావాస్క్రిప్ట్ అసింక్ ఇటరేటర్ హెల్పర్‌లను అన్వేషించండి. మ్యాప్, ఫిల్టర్, టేక్, డ్రాప్ వంటి వాటితో అసమకాలిక డేటా స్ట్రీమ్‌లను సమర్థవంతంగా ఎలా నిర్వహించాలో తెలుసుకోండి.

జావాస్క్రిప్ట్ అసింక్ ఇటరేటర్ హెల్పర్స్: ఆధునిక అప్లికేషన్‌ల కోసం శక్తివంతమైన స్ట్రీమ్ ప్రాసెసింగ్

ఆధునిక జావాస్క్రిప్ట్ అభివృద్ధిలో, అసమకాలిక డేటా స్ట్రీమ్‌లతో వ్యవహరించడం ఒక సాధారణ అవసరం. మీరు ఒక API నుండి డేటాను పొందుతున్నా, పెద్ద ఫైల్‌లను ప్రాసెస్ చేస్తున్నా, లేదా నిజ-సమయ ఈవెంట్‌లను నిర్వహిస్తున్నా, అసమకాలిక డేటాను సమర్థవంతంగా నిర్వహించడం చాలా ముఖ్యం. జావాస్క్రిప్ట్ యొక్క అసింక్ ఇటరేటర్ హెల్పర్స్ ఈ స్ట్రీమ్‌లను ప్రాసెస్ చేయడానికి ఒక శక్తివంతమైన మరియు సులభమైన మార్గాన్ని అందిస్తాయి, డేటా మానిప్యులేషన్‌కు ఫంక్షనల్ మరియు కంపోజబుల్ విధానాన్ని అందిస్తాయి.

అసింక్ ఇటరేటర్లు మరియు అసింక్ ఇటరేబుల్స్ అంటే ఏమిటి?

అసింక్ ఇటరేటర్ హెల్పర్‌లలోకి వెళ్ళే ముందు, వాటి వెనుక ఉన్న భావనలను అర్థం చేసుకుందాం: అసింక్ ఇటరేటర్లు మరియు అసింక్ ఇటరేబుల్స్.

ఒక అసింక్ ఇటరేబుల్ అనేది ఒక ఆబ్జెక్ట్, ఇది దాని విలువలపై అసమకాలికంగా ఇటరేట్ చేయడానికి ఒక మార్గాన్ని నిర్దేశిస్తుంది. ఇది @@asyncIterator మెథడ్‌ను అమలు చేయడం ద్వారా చేస్తుంది, ఇది ఒక అసింక్ ఇటరేటర్ను తిరిగి ఇస్తుంది.

ఒక అసింక్ ఇటరేటర్ అనేది next() మెథడ్‌ను అందించే ఒక ఆబ్జెక్ట్. ఈ మెథడ్ రెండు ప్రాపర్టీలతో ఒక ఆబ్జెక్ట్‌కు రిసాల్వ్ అయ్యే ఒక ప్రామిస్‌ను తిరిగి ఇస్తుంది:

ఇక్కడ ఒక సులభమైన ఉదాహరణ:


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // ఒక అసమకాలిక ఆపరేషన్‌ను అనుకరించండి
    yield i;
  }
}

const asyncIterable = generateSequence(5);

(async () => {
  for await (const value of asyncIterable) {
    console.log(value); // అవుట్‌పుట్: 1, 2, 3, 4, 5 (ప్రతి దాని మధ్య 500ms ఆలస్యంతో)
  }
})();

ఈ ఉదాహరణలో, generateSequence అనేది ఒక అసింక్ జెనరేటర్ ఫంక్షన్, ఇది అసమకాలికంగా సంఖ్యల శ్రేణిని ఉత్పత్తి చేస్తుంది. అసింక్ ఇటరేబుల్ నుండి విలువలను వినియోగించడానికి for await...of లూప్ ఉపయోగించబడుతుంది.

అసింక్ ఇటరేటర్ హెల్పర్‌లను పరిచయం చేస్తున్నాం

అసింక్ ఇటరేటర్ హెల్పర్స్, అసింక్ ఇటరేటర్ల కార్యాచరణను విస్తరిస్తాయి, అసమకాలిక డేటా స్ట్రీమ్‌లను మార్చడానికి, ఫిల్టర్ చేయడానికి మరియు మానిప్యులేట్ చేయడానికి మెథడ్ల సమితిని అందిస్తాయి. అవి ఫంక్షనల్ మరియు కంపోజబుల్ ప్రోగ్రామింగ్ శైలిని ఎనేబుల్ చేస్తాయి, సంక్లిష్టమైన డేటా ప్రాసెసింగ్ పైప్‌లైన్‌లను నిర్మించడం సులభతరం చేస్తాయి.

ప్రధాన అసింక్ ఇటరేటర్ హెల్పర్‌లు:

ప్రతి హెల్పర్‌ను ఉదాహరణలతో అన్వేషిద్దాం.

map()

map() హెల్పర్ అసింక్ ఇటరేబుల్ యొక్క ప్రతి ఎలిమెంట్‌ను అందించిన ఫంక్షన్‌ను ఉపయోగించి మారుస్తుంది. ఇది మార్చబడిన విలువలతో కొత్త అసింక్ ఇటరేబుల్‌ను తిరిగి ఇస్తుంది.


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

const doubledIterable = asyncIterable.map(x => x * 2);

(async () => {
  for await (const value of doubledIterable) {
    console.log(value); // అవుట్‌పుట్: 2, 4, 6, 8, 10 (100ms ఆలస్యంతో)
  }
})();

ఈ ఉదాహరణలో, map(x => x * 2) శ్రేణిలోని ప్రతి సంఖ్యను రెట్టింపు చేస్తుంది.

filter()

filter() హెల్పర్ అందించిన షరతు (ప్రిడికేట్ ఫంక్షన్) ఆధారంగా అసింక్ ఇటరేబుల్ నుండి ఎలిమెంట్‌లను ఎంచుకుంటుంది. ఇది షరతును సంతృప్తి చేసే ఎలిమెంట్‌లను మాత్రమే కలిగి ఉన్న కొత్త అసింక్ ఇటరేబుల్‌ను తిరిగి ఇస్తుంది.


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(10);

const evenNumbersIterable = asyncIterable.filter(x => x % 2 === 0);

(async () => {
  for await (const value of evenNumbersIterable) {
    console.log(value); // అవుట్‌పుట్: 2, 4, 6, 8, 10 (100ms ఆలస్యంతో)
  }
})();

ఈ ఉదాహరణలో, filter(x => x % 2 === 0) శ్రేణి నుండి సరి సంఖ్యలను మాత్రమే ఎంచుకుంటుంది.

take()

take() హెల్పర్ అసింక్ ఇటరేబుల్ నుండి మొదటి N ఎలిమెంట్‌లను తిరిగి ఇస్తుంది. ఇది నిర్దిష్ట సంఖ్యలో ఎలిమెంట్‌లను మాత్రమే కలిగి ఉన్న కొత్త అసింక్ ఇటరేబుల్‌ను తిరిగి ఇస్తుంది.


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

const firstThreeIterable = asyncIterable.take(3);

(async () => {
  for await (const value of firstThreeIterable) {
    console.log(value); // అవుట్‌పుట్: 1, 2, 3 (100ms ఆలస్యంతో)
  }
})();

ఈ ఉదాహరణలో, take(3) శ్రేణి నుండి మొదటి మూడు సంఖ్యలను ఎంచుకుంటుంది.

drop()

drop() హెల్పర్ అసింక్ ఇటరేబుల్ నుండి మొదటి N ఎలిమెంట్‌లను వదిలివేసి మిగిలిన వాటిని తిరిగి ఇస్తుంది. ఇది మిగిలిన ఎలిమెంట్‌లను కలిగి ఉన్న కొత్త అసింక్ ఇటరేబుల్‌ను తిరిగి ఇస్తుంది.


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

const afterFirstTwoIterable = asyncIterable.drop(2);

(async () => {
  for await (const value of afterFirstTwoIterable) {
    console.log(value); // అవుట్‌పుట్: 3, 4, 5 (100ms ఆలస్యంతో)
  }
})();

ఈ ఉదాహరణలో, drop(2) శ్రేణి నుండి మొదటి రెండు సంఖ్యలను వదిలివేస్తుంది.

toArray()

toArray() హెల్పర్ మొత్తం అసింక్ ఇటరేబుల్‌ను వినియోగించి, అన్ని ఎలిమెంట్‌లను ఒక అర్రేలోకి సేకరిస్తుంది. ఇది అన్ని ఎలిమెంట్‌లను కలిగి ఉన్న అర్రేకు రిసాల్వ్ అయ్యే ఒక ప్రామిస్‌ను తిరిగి ఇస్తుంది.


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

(async () => {
  const numbersArray = await asyncIterable.toArray();
  console.log(numbersArray); // అవుట్‌పుట్: [1, 2, 3, 4, 5]
})();

ఈ ఉదాహరణలో, toArray() శ్రేణి నుండి అన్ని సంఖ్యలను ఒక అర్రేలోకి సేకరిస్తుంది.

forEach()

forEach() హెల్పర్ అసింక్ ఇటరేబుల్‌లోని ప్రతి ఎలిమెంట్ కోసం ఒకసారి అందించిన ఫంక్షన్‌ను అమలు చేస్తుంది. ఇది కొత్త అసింక్ ఇటరేబుల్‌ను తిరిగి ఇవ్వదు, ఇది ఫంక్షన్‌ను సైడ్-ఎఫెక్ట్‌గా అమలు చేస్తుంది. లాగింగ్ లేదా UIని అప్‌డేట్ చేయడం వంటి ఆపరేషన్‌లు చేయడానికి ఇది ఉపయోగకరంగా ఉంటుంది.


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(3);

(async () => {
  await asyncIterable.forEach(value => {
    console.log("Value:", value);
  });
  console.log("forEach completed");
})();
// అవుట్‌పుట్: Value: 1, Value: 2, Value: 3, forEach completed

some()

some() హెల్పర్ అసింక్ ఇటరేబుల్‌లో కనీసం ఒక ఎలిమెంట్ అందించిన ఫంక్షన్ ద్వారా అమలు చేయబడిన పరీక్షను పాస్ అవుతుందో లేదో పరీక్షిస్తుంది. ఇది బూలియన్ విలువకు (true కనీసం ఒక ఎలిమెంట్ షరతును సంతృప్తి చేస్తే, లేకపోతే false) రిసాల్వ్ అయ్యే ఒక ప్రామిస్‌ను తిరిగి ఇస్తుంది.


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

(async () => {
  const hasEvenNumber = await asyncIterable.some(x => x % 2 === 0);
  console.log("Has even number:", hasEvenNumber); // అవుట్‌పుట్: Has even number: true
})();

every()

every() హెల్పర్ అసింక్ ఇటరేబుల్‌లోని అన్ని ఎలిమెంట్‌లు అందించిన ఫంక్షన్ ద్వారా అమలు చేయబడిన పరీక్షను పాస్ అవుతాయో లేదో పరీక్షిస్తుంది. ఇది బూలియన్ విలువకు (true అన్ని ఎలిమెంట్‌లు షరతును సంతృప్తి చేస్తే, లేకపోతే false) రిసాల్వ్ అయ్యే ఒక ప్రామిస్‌ను తిరిగి ఇస్తుంది.


async function* generateSequence(end) {
  for (let i = 2; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(4);

(async () => {
  const areAllEven = await asyncIterable.every(x => x % 2 === 0);
  console.log("Are all even:", areAllEven); // అవుట్‌పుట్: Are all even: true
})();

find()

find() హెల్పర్ అందించిన పరీక్ష ఫంక్షన్‌ను సంతృప్తి చేసే అసింక్ ఇటరేబుల్‌లోని మొదటి ఎలిమెంట్‌ను తిరిగి ఇస్తుంది. ఏ విలువలు పరీక్ష ఫంక్షన్‌ను సంతృప్తి చేయకపోతే, undefined తిరిగి ఇవ్వబడుతుంది. ఇది కనుగొనబడిన ఎలిమెంట్ లేదా undefinedకు రిసాల్వ్ అయ్యే ఒక ప్రామిస్‌ను తిరిగి ఇస్తుంది.


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

(async () => {
  const firstEven = await asyncIterable.find(x => x % 2 === 0);
  console.log("First even number:", firstEven); // అవుట్‌పుట్: First even number: 2
})();

reduce()

reduce() హెల్పర్ అసింక్ ఇటరేబుల్ యొక్క ప్రతి ఎలిమెంట్‌పై వినియోగదారు-అందించిన "రిడ్యూసర్" కాల్‌బ్యాక్ ఫంక్షన్‌ను క్రమంలో అమలు చేస్తుంది, మునుపటి ఎలిమెంట్‌పై గణన నుండి తిరిగి వచ్చిన విలువను పాస్ చేస్తుంది. అన్ని ఎలిమెంట్‌లపై రిడ్యూసర్‌ను అమలు చేయడం యొక్క చివరి ఫలితం ఒకే విలువ. ఇది చివరిగా సేకరించబడిన విలువకు రిసాల్వ్ అయ్యే ఒక ప్రామిస్‌ను తిరిగి ఇస్తుంది.


async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(5);

(async () => {
  const sum = await asyncIterable.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
  console.log("Sum:", sum); // అవుట్‌పుట్: Sum: 15
})();

ప్రాక్టికల్ ఉదాహరణలు మరియు వినియోగ కేసులు

అసింక్ ఇటరేటర్ హెల్పర్స్ వివిధ సందర్భాలలో విలువైనవి. కొన్ని ప్రాక్టికల్ ఉదాహరణలను అన్వేషిద్దాం:

1. స్ట్రీమింగ్ API నుండి డేటాను ప్రాసెస్ చేయడం

మీరు ఒక స్ట్రీమింగ్ API నుండి డేటాను స్వీకరించే నిజ-సమయ డేటా విజువలైజేషన్ డాష్‌బోర్డ్‌ను నిర్మిస్తున్నారని ఊహించుకోండి. API నిరంతరం అప్‌డేట్‌లను పంపుతుంది, మరియు మీరు తాజా సమాచారాన్ని ప్రదర్శించడానికి ఈ అప్‌డేట్‌లను ప్రాసెస్ చేయాలి.


async function* fetchDataFromAPI(url) {
  let response = await fetch(url);

  if (!response.body) {
    throw new Error("ReadableStream not supported in this environment");
  }

  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        break;
      }
      const chunk = decoder.decode(value);
      // API న్యూలైన్‌లతో వేరు చేయబడిన JSON ఆబ్జెక్ట్‌లను పంపుతుందని అనుకుందాం
      const lines = chunk.split('\n');
      for (const line of lines) {
        if (line.trim() !== '') {
          yield JSON.parse(line);
        }
      }
    }
  } finally {
    reader.releaseLock();
  }
}

const apiURL = 'https://example.com/streaming-api'; // మీ API URLతో భర్తీ చేయండి
const dataStream = fetchDataFromAPI(apiURL);

// డేటా స్ట్రీమ్‌ను ప్రాసెస్ చేయండి
(async () => {
  for await (const data of dataStream.filter(item => item.type === 'metric').map(item => ({ timestamp: item.timestamp, value: item.value }))) {
    console.log('Processed Data:', data);
    // ప్రాసెస్ చేయబడిన డేటాతో డాష్‌బోర్డ్‌ను అప్‌డేట్ చేయండి
  }
})();

ఈ ఉదాహరణలో, fetchDataFromAPI ఒక స్ట్రీమింగ్ API నుండి డేటాను పొందుతుంది, JSON ఆబ్జెక్ట్‌లను పార్స్ చేస్తుంది, మరియు వాటిని అసింక్ ఇటరేబుల్‌గా ఇస్తుంది. filter హెల్పర్ మెట్రిక్‌లను మాత్రమే ఎంచుకుంటుంది, మరియు map హెల్పర్ డాష్‌బోర్డ్‌ను అప్‌డేట్ చేయడానికి ముందు డేటాను కావలసిన ఫార్మాట్‌లోకి మారుస్తుంది.

2. పెద్ద ఫైల్‌లను చదవడం మరియు ప్రాసెస్ చేయడం

మీరు కస్టమర్ డేటాను కలిగి ఉన్న పెద్ద CSV ఫైల్‌ను ప్రాసెస్ చేయాలని అనుకుందాం. మొత్తం ఫైల్‌ను మెమరీలోకి లోడ్ చేయడానికి బదులుగా, మీరు దానిని చంక్-బై-చంక్ ప్రాసెస్ చేయడానికి అసింక్ ఇటరేటర్ హెల్పర్‌లను ఉపయోగించవచ్చు.


async function* readLinesFromFile(filePath) {
  const file = await fsPromises.open(filePath, 'r');

  try {
    let buffer = Buffer.alloc(1024);
    let fileOffset = 0;
    let remainder = '';

    while (true) {
      const { bytesRead } = await file.read(buffer, 0, buffer.length, fileOffset);
      if (bytesRead === 0) {
        if (remainder) {
          yield remainder;
        }
        break;
      }

      fileOffset += bytesRead;
      const chunk = buffer.toString('utf8', 0, bytesRead);
      const lines = chunk.split('\n');

      lines[0] = remainder + lines[0];
      remainder = lines.pop() || '';

      for (const line of lines) {
        yield line;
      }
    }
  } finally {
    await file.close();
  }
}

const filePath = './customer_data.csv'; // మీ ఫైల్ పాత్‌తో భర్తీ చేయండి
const lines = readLinesFromFile(filePath);

// లైన్‌లను ప్రాసెస్ చేయండి
(async () => {
  for await (const customerData of lines.drop(1).map(line => line.split(',')).filter(data => data[2] === 'USA')) {
    console.log('Customer from USA:', customerData);
    // USA నుండి కస్టమర్ డేటాను ప్రాసెస్ చేయండి
  }
})();

ఈ ఉదాహరణలో, readLinesFromFile ఫైల్‌ను లైన్-బై-లైన్ చదివి ప్రతి లైన్‌ను అసింక్ ఇటరేబుల్‌గా ఇస్తుంది. drop(1) హెల్పర్ హెడర్ రోను వదిలివేస్తుంది, map హెల్పర్ లైన్‌ను కాలమ్‌లుగా విభజిస్తుంది, మరియు filter హెల్పర్ USA నుండి కస్టమర్‌లను మాత్రమే ఎంచుకుంటుంది.

3. నిజ-సమయ ఈవెంట్‌లను నిర్వహించడం

అసింక్ ఇటరేటర్ హెల్పర్‌లను వెబ్‌సాకెట్స్ వంటి మూలాల నుండి నిజ-సమయ ఈవెంట్‌లను నిర్వహించడానికి కూడా ఉపయోగించవచ్చు. మీరు ఈవెంట్‌లు వచ్చినప్పుడు వాటిని విడుదల చేసే ఒక అసింక్ ఇటరేబుల్‌ను సృష్టించి, ఆపై ఈ ఈవెంట్‌లను ప్రాసెస్ చేయడానికి హెల్పర్‌లను ఉపయోగించవచ్చు.


async function* createWebSocketStream(url) {
  const ws = new WebSocket(url);

  yield new Promise((resolve, reject) => {
      ws.onopen = () => {
          resolve();
      };
      ws.onerror = (error) => {
          reject(error);
      };
  });

  try {
    while (ws.readyState === WebSocket.OPEN) {
      yield new Promise((resolve, reject) => {
        ws.onmessage = (event) => {
          resolve(JSON.parse(event.data));
        };
        ws.onerror = (error) => {
          reject(error);
        };
        ws.onclose = () => {
           resolve(null); // కనెక్షన్ మూసివేసినప్పుడు nullతో రిసాల్వ్ చేయండి
        }
      });

    }
  } finally {
    ws.close();
  }
}

const websocketURL = 'wss://example.com/events'; // మీ వెబ్‌సాకెట్ URLతో భర్తీ చేయండి
const eventStream = createWebSocketStream(websocketURL);

// ఈవెంట్ స్ట్రీమ్‌ను ప్రాసెస్ చేయండి
(async () => {
  for await (const event of eventStream.filter(event => event.type === 'user_login').map(event => ({ userId: event.userId, timestamp: event.timestamp }))) {
    console.log('User Login Event:', event);
    // యూజర్ లాగిన్ ఈవెంట్‌ను ప్రాసెస్ చేయండి
  }
})();

ఈ ఉదాహరణలో, createWebSocketStream ఒక వెబ్‌సాకెట్ నుండి స్వీకరించబడిన ఈవెంట్‌లను విడుదల చేసే ఒక అసింక్ ఇటరేబుల్‌ను సృష్టిస్తుంది. filter హెల్పర్ యూజర్ లాగిన్ ఈవెంట్‌లను మాత్రమే ఎంచుకుంటుంది, మరియు map హెల్పర్ డేటాను కావలసిన ఫార్మాట్‌లోకి మారుస్తుంది.

అసింక్ ఇటరేటర్ హెల్పర్‌లను ఉపయోగించడం వల్ల ప్రయోజనాలు

బ్రౌజర్ మరియు రన్‌టైమ్ మద్దతు

అసింక్ ఇటరేటర్ హెల్పర్స్ జావాస్క్రిప్ట్‌లో ఇప్పటికీ సాపేక్షంగా కొత్త ఫీచర్. 2024 చివరి నాటికి, అవి TC39 ప్రామాణీకరణ ప్రక్రియలో స్టేజ్ 3లో ఉన్నాయి, అంటే అవి సమీప భవిష్యత్తులో ప్రామాణీకరించబడే అవకాశం ఉంది. అయినప్పటికీ, అవి ఇంకా అన్ని బ్రౌజర్‌లు మరియు Node.js వెర్షన్‌లలో స్థానికంగా మద్దతు ఇవ్వబడలేదు.

బ్రౌజర్ మద్దతు: Chrome, Firefox, Safari, మరియు Edge వంటి ఆధునిక బ్రౌజర్‌లు క్రమంగా అసింక్ ఇటరేటర్ హెల్పర్‌లకు మద్దతును జోడిస్తున్నాయి. ఈ ఫీచర్‌కు ఏ బ్రౌజర్‌లు మద్దతిస్తాయో చూడటానికి మీరు Can I use... వంటి వెబ్‌సైట్‌లలో తాజా బ్రౌజర్ అనుకూలత సమాచారాన్ని తనిఖీ చేయవచ్చు.

Node.js మద్దతు: Node.js యొక్క ఇటీవలి వెర్షన్‌లు (v18 మరియు అంతకంటే ఎక్కువ) అసింక్ ఇటరేటర్ హెల్పర్‌లకు ప్రయోగాత్మక మద్దతును అందిస్తాయి. వాటిని ఉపయోగించడానికి, మీరు Node.jsను --experimental-async-iterator ఫ్లాగ్‌తో అమలు చేయవలసి రావచ్చు.

పాలిఫిల్స్: వాటికి స్థానికంగా మద్దతు లేని పర్యావరణాలలో మీరు అసింక్ ఇటరేటర్ హెల్పర్‌లను ఉపయోగించాలనుకుంటే, మీరు ఒక పాలిఫిల్‌ను ఉపయోగించవచ్చు. ఒక పాలిఫిల్ అనేది తప్పిపోయిన కార్యాచరణను అందించే కోడ్ ముక్క. అసింక్ ఇటరేటర్ హెల్పర్‌ల కోసం అనేక పాలిఫిల్ లైబ్రరీలు అందుబాటులో ఉన్నాయి; core-js లైబ్రరీ ఒక ప్రసిద్ధ ఎంపిక.

కస్టమ్ అసింక్ ఇటరేటర్లను అమలు చేయడం

అసింక్ ఇటరేటర్ హెల్పర్స్ ఇప్పటికే ఉన్న అసింక్ ఇటరేబుల్స్‌ను ప్రాసెస్ చేయడానికి ఒక అనుకూలమైన మార్గాన్ని అందిస్తున్నప్పటికీ, మీరు కొన్నిసార్లు మీ స్వంత కస్టమ్ అసింక్ ఇటరేటర్లను సృష్టించవలసి రావచ్చు. ఇది డేటాబేస్‌లు, APIలు, లేదా ఫైల్ సిస్టమ్‌ల వంటి వివిధ మూలాల నుండి డేటాను స్ట్రీమింగ్ పద్ధతిలో నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది.

ఒక కస్టమ్ అసింక్ ఇటరేటర్‌ను సృష్టించడానికి, మీరు ఒక ఆబ్జెక్ట్‌పై @@asyncIterator మెథడ్‌ను అమలు చేయాలి. ఈ మెథడ్ next() మెథడ్‌తో ఒక ఆబ్జెక్ట్‌ను తిరిగి ఇవ్వాలి. next() మెథడ్ value మరియు done ప్రాపర్టీలతో ఒక ఆబ్జెక్ట్‌కు రిసాల్వ్ అయ్యే ఒక ప్రామిస్‌ను తిరిగి ఇవ్వాలి.

ఇక్కడ ఒక పేజినేటెడ్ API నుండి డేటాను పొందే కస్టమ్ అసింక్ ఇటరేటర్ యొక్క ఉదాహరణ:


async function* fetchPaginatedData(baseURL) {
  let page = 1;
  let hasMore = true;

  while (hasMore) {
    const url = `${baseURL}?page=${page}`;
    const response = await fetch(url);
    const data = await response.json();

    if (data.results.length === 0) {
      hasMore = false;
      break;
    }

    for (const item of data.results) {
      yield item;
    }

    page++;
  }
}

const apiBaseURL = 'https://api.example.com/data'; // మీ API URLతో భర్తీ చేయండి
const paginatedData = fetchPaginatedData(apiBaseURL);

// పేజినేటెడ్ డేటాను ప్రాసెస్ చేయండి
(async () => {
  for await (const item of paginatedData) {
    console.log('Item:', item);
    // ఐటెమ్‌ను ప్రాసెస్ చేయండి
  }
})();

ఈ ఉదాహరణలో, fetchPaginatedData ఒక పేజినేటెడ్ API నుండి డేటాను పొందుతుంది, ప్రతి ఐటెమ్‌ను అది తిరిగి పొందినప్పుడు ఇస్తుంది. అసింక్ ఇటరేటర్ పేజినేషన్ లాజిక్‌ను నిర్వహిస్తుంది, డేటాను స్ట్రీమింగ్ పద్ధతిలో వినియోగించడం సులభతరం చేస్తుంది.

సంభావ్య సవాళ్లు మరియు పరిగణనలు

అసింక్ ఇటరేటర్ హెల్పర్స్ అనేక ప్రయోజనాలను అందిస్తున్నప్పటికీ, కొన్ని సంభావ్య సవాళ్లు మరియు పరిగణనల గురించి తెలుసుకోవడం ముఖ్యం:

అసింక్ ఇటరేటర్ హెల్పర్‌లను ఉపయోగించడానికి ఉత్తమ పద్ధతులు

అసింక్ ఇటరేటర్ హెల్పర్‌ల నుండి గరిష్ట ప్రయోజనం పొందడానికి, క్రింది ఉత్తమ పద్ధతులను పరిగణించండి:

అధునాతన టెక్నిక్‌లు

కస్టమ్ హెల్పర్‌లను కంపోజ్ చేయడం

మీరు ఇప్పటికే ఉన్న హెల్పర్‌లను కంపోజ్ చేయడం ద్వారా లేదా మొదటి నుండి కొత్తవి నిర్మించడం ద్వారా మీ స్వంత కస్టమ్ అసింక్ ఇటరేటర్ హెల్పర్‌లను సృష్టించవచ్చు. ఇది మీ నిర్దిష్ట అవసరాలకు కార్యాచరణను అనుకూలీకరించడానికి మరియు పునర్వినియోగ భాగాలను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది.


async function* takeWhile(asyncIterable, predicate) {
  for await (const value of asyncIterable) {
    if (!predicate(value)) {
      break;
    }
    yield value;
  }
}

// వినియోగ ఉదాహరణ:
async function* generateSequence(end) {
  for (let i = 1; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i;
  }
}

const asyncIterable = generateSequence(10);
const firstFive = takeWhile(asyncIterable, x => x <= 5);

(async () => {
  for await (const value of firstFive) {
    console.log(value);
  }
})();

బహుళ అసింక్ ఇటరేబుల్స్‌ను కలపడం

మీరు zip లేదా merge వంటి టెక్నిక్‌లను ఉపయోగించి బహుళ అసింక్ ఇటరేబుల్స్‌ను ఒకే అసింక్ ఇటరేబుల్‌గా కలపవచ్చు. ఇది బహుళ మూలాల నుండి డేటాను ఏకకాలంలో ప్రాసెస్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.


async function* zip(asyncIterable1, asyncIterable2) {
    const iterator1 = asyncIterable1[Symbol.asyncIterator]();
    const iterator2 = asyncIterable2[Symbol.asyncIterator]();

    while (true) {
        const result1 = await iterator1.next();
        const result2 = await iterator2.next();

        if (result1.done || result2.done) {
            break;
        }

        yield [result1.value, result2.value];
    }
}

// వినియోగ ఉదాహరణ:
async function* generateSequence1(end) {
    for (let i = 1; i <= end; i++) {
        yield i;
    }
}

async function* generateSequence2(end) {
    for (let i = 10; i <= end + 9; i++) {
        yield i;
    }
}

const iterable1 = generateSequence1(5);
const iterable2 = generateSequence2(5);

(async () => {
    for await (const [value1, value2] of zip(iterable1, iterable2)) {
        console.log(value1, value2);
    }
})();

ముగింపు

జావాస్క్రిప్ట్ అసింక్ ఇటరేటర్ హెల్పర్స్ అసమకాలిక డేటా స్ట్రీమ్‌లను ప్రాసెస్ చేయడానికి ఒక శక్తివంతమైన మరియు సులభమైన మార్గాన్ని అందిస్తాయి. అవి డేటా మానిప్యులేషన్‌కు ఫంక్షనల్ మరియు కంపోజబుల్ విధానాన్ని అందిస్తాయి, సంక్లిష్టమైన డేటా ప్రాసెసింగ్ పైప్‌లైన్‌లను నిర్మించడం సులభతరం చేస్తాయి. అసింక్ ఇటరేటర్లు మరియు అసింక్ ఇటరేబుల్స్ యొక్క ప్రధాన భావనలను అర్థం చేసుకోవడం మరియు వివిధ హెల్పర్ మెథడ్స్‌లో నైపుణ్యం సాధించడం ద్వారా, మీరు మీ అసమకాలిక జావాస్క్రిప్ట్ కోడ్ యొక్క సామర్థ్యం మరియు నిర్వహణను గణనీయంగా మెరుగుపరచవచ్చు. బ్రౌజర్ మరియు రన్‌టైమ్ మద్దతు పెరుగుతున్న కొద్దీ, అసింక్ ఇటరేటర్ హెల్పర్స్ ఆధునిక జావాస్క్రిప్ట్ డెవలపర్‌లకు ఒక ముఖ్యమైన సాధనంగా మారడానికి సిద్ధంగా ఉన్నాయి.